package container

import (
	"codejy/store"
	"codejy/structdef"
	"codejy/typedefault"
	"codejy/utils"
	"strconv"
)

type TypeQueue struct {
	Addr        string
	ThreadStore *structdef.ThreadStore
	Queue       *utils.Queue[string]
}

// 创建实例

func (a *TypeQueue) CreateTypeDefault(addr string, threadStore *structdef.ThreadStore, parameter ...string) {
	queue := &TypeQueue{
		Addr:        addr,
		ThreadStore: threadStore,
		Queue:       utils.NewQueue[string](),
	}

	store.AddTypeDefaultInstanceStore(threadStore, a.GetTypeName(), addr, queue)
}
func (a *TypeQueue) GetData() interface{} {
	return a.Queue
}
func (a *TypeQueue) ToStr() string {
	var Str string
	//如果是queue,那么打印出来
	value5, b5 := typedefault.GetTypeDefaultValue[*utils.Queue[string]](a.ThreadStore, a.GetTypeName(), a.Addr)
	if b5 {
		queueDatas := value5.Values()
		Str = "["
		//以逗号分隔
		for _, v := range queueDatas {
			Str += v + ","
		}
		Str = Str[:len(Str)-1]
		Str += "]"
		return a.GetTypeName() + ":" + Str
	}
	return ""
}
func (a *TypeQueue) ParameterProcessing(parameter []string) []string {
	return parameter
}

// 添加队列尾
func (a *TypeQueue) PushTail(value string) {
	a.Queue.PushTail(value)
}

// 添加队列头
func (a *TypeQueue) PushHead(value string) {

	a.Queue.PushHead(value)
}

// 弹出队列尾
func (a *TypeQueue) PopTail() string {
	return a.Queue.PopTail()
}

// 弹出队列头
func (a *TypeQueue) PopHead() string {

	return a.Queue.PopHead()
}

// 获取数量
func (a *TypeQueue) Len() string {

	return strconv.Itoa(a.Queue.Len())
}

// 将队列转换为List
func (a *TypeQueue) ToList() string {

	values := a.Queue.Values()

	return SliceToList(values, a.ThreadStore)
}

// 弹出队列尾部,如果队列是空那么等待,直到队列不为空获取队列尾部
// time: 弹出队列尾部,如果队列是空那么等待一定时间,如果在等待时间内队列不为空获取队列尾部,如果等待时间到了那么返回空
func (a *TypeQueue) PopTailWait(time string) string {
	if time == `""` {
		return a.Queue.PopTailWait()
	} else {
		atoi, _ := strconv.Atoi(time)
		return a.Queue.PopTailWaitTime(atoi)
	}

}

// 弹出队列头部,如果队列是空那么等待,直到队列不为空获取队列头部
// time: 弹出队列头部,如果队列是空那么等待一定时间,如果在等待时间内队列不为空获取队列头部,如果等待时间到了那么返回空
func (a *TypeQueue) PopHeadWait(time string) string {
	if time == `""` {
		return a.Queue.PopHeadWait()
	} else {
		atoi, _ := strconv.Atoi(time)
		return a.Queue.PopHeadWaitTime(atoi)
	}
}

func (a *TypeQueue) GetDef() string {
	return `
		@CodeManual(def="new("Queue")",des="创建Queue容器")
		type  Queue{
			def init{
				core&CreateTypeDefault()
			}

			@CodeManual(def="pushTail($1)",des="添加队列尾,例:queue.pushTail("1")")
			def pushTail{
				core&PushTail($1)
            }
	
			@CodeManual(def="pushHead($1)",des="添加队列头,例:queue.pushHead("1")")
			def pushHead{
				core&PushHead($1)	
			}

			@CodeManual(def="popTail()",des="队列尾弹出数据,例:queue.popTail()")
			def popTail{
				to core&PopTail()	
			}
	
			@CodeManual(def="popTailWait($1)",des="队列尾弹出数据(如果没有一直等待,也可以设置等待时间(ms)),例:queue.popTailWait()")
			def popTailWait{
				to core&PopTailWait($1)	
			}	
		
			@CodeManual(def="popHead()",des="队列头弹出数据,例:queue.popHead()")
			def popHead{
				to core&PopHead()
			}	

			@CodeManual(def="popHeadWait($1)",des="队列头弹出数据(如果没有一直等待,也可以设置等待时间(ms)),例:queue.popHeadWait()")
			def popHeadWait{
				to core&PopHeadWait($1)
			}

			@CodeManual(def="size()",des="获取队列数量,例:queue.size()")
			def size{
				to core&Len()
			}
			@CodeManual(def="toList()",des="将队列转换为List,例:queue.toList()")
			def toList{
				to core&ToList()
			}
			
			def toStr{
				to core&ToStr()
			}
		}
	`
}
func init() {
	typedefault.RegisterTypeDefault(&TypeQueue{})
}

func (a *TypeQueue) GetTypeName() string {
	return "Queue"
}
